// 引入ASP.NET Core MVC控制器相关命名空间
using Microsoft.AspNetCore.Mvc;
// 引入项目中的数据传输对象
using Rabbit3.Api.Dto;
// 引入项目中的服务接口
using Rabbit3.Api.Services;
// 引入数据验证相关命名空间
using System.ComponentModel.DataAnnotations;

namespace Rabbit3.Api.Controllers
{
    /// <summary>
    /// 养殖管理控制器 - 负责处理养殖阶段相关的HTTP请求
    /// 提供养殖信息、免疫信息、企业信息的增删改查功能
    /// </summary>
    [ApiController] // 标识这是一个API控制器，自动处理模型验证和错误响应
    [Route("api/[controller]")] // 设置路由前缀为 api/Farming
    public class FarmingController : ControllerBase
    {
        // 养殖服务接口，用于处理养殖相关的业务逻辑
        private readonly IFarmingService _farmingService;
        // 日志记录器，用于记录操作日志和错误信息
        private readonly ILogger<FarmingController> _logger;

        /// <summary>
        /// 构造函数 - 通过依赖注入初始化控制器
        /// </summary>
        /// <param name="farmingService">养殖服务实例</param>
        /// <param name="logger">日志记录器实例</param>
        public FarmingController(IFarmingService farmingService, ILogger<FarmingController> logger)
        {
            // 初始化养殖服务
            _farmingService = farmingService;
            // 初始化日志记录器
            _logger = logger;
        }

        /// <summary>
        /// 根据溯源信息ID获取对应的养殖信息详情
        /// </summary>
        /// <param name="traceabilityId">溯源信息ID</param>
        /// <returns>养殖信息详情，如果不存在返回404</returns>
        [HttpGet("by-traceability/{traceabilityId}")] // HTTP GET请求，路径为 api/Farming/by-traceability/{traceabilityId}
        public async Task<ActionResult<FarmingResponseDto>> GetByTraceabilityId(int traceabilityId)
        {
            try
            {
                // 根据溯源信息ID查询养殖信息
                var result = await _farmingService.GetByTraceabilityIdAsync(traceabilityId);
                // 如果查询结果为空，返回404未找到
                if (result == null)
                {
                    return NotFound(new { message = "未找到指定的养殖信息", success = false });
                }
                // 返回200状态码和查询结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含溯源信息ID参数
                _logger.LogError(ex, "获取养殖信息失败，溯源信息ID: {TraceabilityId}", traceabilityId);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "获取失败", success = false });
            }
        }

        /// <summary>
        /// 根据养殖信息ID获取单个养殖信息详情
        /// </summary>
        /// <param name="id">养殖信息ID</param>
        /// <returns>养殖信息详情，如果不存在返回404</returns>
        [HttpGet("{id}")] // HTTP GET请求，路径为 api/Farming/{id}
        public async Task<ActionResult<FarmingResponseDto>> GetById(int id)
        {
            try
            {
                // 根据ID查询养殖信息
                var result = await _farmingService.GetByIdAsync(id);
                // 如果查询结果为空，返回404未找到
                if (result == null)
                {
                    return NotFound(new { message = "未找到指定的养殖信息", success = false });
                }
                // 返回200状态码和查询结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "获取养殖信息失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "获取失败", success = false });
            }
        }

        /// <summary>
        /// 创建新的养殖信息
        /// </summary>
        /// <param name="createDto">创建养殖信息的DTO对象</param>
        /// <returns>创建成功返回201状态码和新创建的养殖信息</returns>
        [HttpPost] // HTTP POST请求，路径为 api/Farming
        public async Task<ActionResult<FarmingResponseDto>> Create([FromBody] CreateFarmingDto createDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层创建养殖信息
                var result = await _farmingService.CreateAsync(createDto);
                // 返回201创建成功状态码，并在Location头中返回新资源的URL
                return CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
            }
            catch (Exception ex)
            {
                // 记录错误日志
                _logger.LogError(ex, "创建养殖信息失败");
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "创建失败", success = false });
            }
        }

        /// <summary>
        /// 更新现有的养殖信息
        /// </summary>
        /// <param name="updateDto">包含更新数据的DTO对象</param>
        /// <returns>更新成功返回200状态码和更新后的养殖信息</returns>
        [HttpPut] // HTTP PUT请求，路径为 api/Farming
        public async Task<ActionResult<FarmingResponseDto>> Update([FromBody] UpdateFarmingDto updateDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层更新养殖信息
                var result = await _farmingService.UpdateAsync(updateDto);
                // 如果更新失败（未找到记录），返回404未找到
                if (result == null)
                {
                    return NotFound(new { message = "未找到指定的养殖信息", success = false });
                }
                // 返回200状态码和更新后的结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含更新DTO的ID
                _logger.LogError(ex, "更新养殖信息失败，ID: {Id}", updateDto.Id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "更新失败", success = false });
            }
        }

        /// <summary>
        /// 软删除指定的养殖信息（逻辑删除，不物理删除）
        /// </summary>
        /// <param name="id">要删除的养殖信息ID</param>
        /// <returns>删除结果，包含成功/失败状态和消息</returns>
        [HttpDelete("{id}")] // HTTP DELETE请求，路径为 api/Farming/{id}
        public async Task<ActionResult<object>> Delete(int id)
        {
            try
            {
                // 调用服务层执行软删除操作
                var result = await _farmingService.DeleteAsync(id);
                // 如果删除失败（未找到记录），返回404未找到
                if (!result)
                {
                    return NotFound(new { message = "未找到指定的养殖信息", success = false });
                }
                // 返回200状态码和成功消息
                return Ok(new { message = "删除成功", success = true });
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "删除养殖信息失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "删除失败", success = false });
            }
        }

        /// <summary>
        /// 创建新的免疫信息（疫苗注射记录）
        /// </summary>
        /// <param name="createDto">创建免疫信息的DTO对象</param>
        /// <returns>创建成功返回200状态码和新创建的免疫信息</returns>
        [HttpPost("immunity")] // HTTP POST请求，路径为 api/Farming/immunity
        public async Task<ActionResult<ImmunityResponseDto>> CreateImmunity([FromBody] CreateImmunityDto createDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层创建免疫信息
                var result = await _farmingService.CreateImmunityAsync(createDto);
                // 返回200状态码和创建结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志
                _logger.LogError(ex, "创建免疫信息失败");
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "创建失败", success = false });
            }
        }

        /// <summary>
        /// 更新现有的免疫信息
        /// </summary>
        /// <param name="updateDto">包含更新数据的DTO对象</param>
        /// <returns>更新成功返回200状态码和更新后的免疫信息</returns>
        [HttpPut("immunity")] // HTTP PUT请求，路径为 api/Farming/immunity
        public async Task<ActionResult<ImmunityResponseDto>> UpdateImmunity([FromBody] UpdateImmunityDto updateDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层更新免疫信息
                var result = await _farmingService.UpdateImmunityAsync(updateDto);
                // 如果更新失败（未找到记录），返回404未找到
                if (result == null)
                {
                    return NotFound(new { message = "未找到指定的免疫信息", success = false });
                }
                // 返回200状态码和更新后的结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含更新DTO的ID
                _logger.LogError(ex, "更新免疫信息失败，ID: {Id}", updateDto.Id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "更新失败", success = false });
            }
        }

        /// <summary>
        /// 软删除指定的免疫信息（逻辑删除，不物理删除）
        /// </summary>
        /// <param name="id">要删除的免疫信息ID</param>
        /// <returns>删除结果，包含成功/失败状态和消息</returns>
        [HttpDelete("immunity/{id}")] // HTTP DELETE请求，路径为 api/Farming/immunity/{id}
        public async Task<ActionResult<object>> DeleteImmunity(int id)
        {
            try
            {
                // 调用服务层执行软删除操作
                var result = await _farmingService.DeleteImmunityAsync(id);
                // 如果删除失败（未找到记录），返回404未找到
                if (!result)
                {
                    return NotFound(new { message = "未找到指定的免疫信息", success = false });
                }
                // 返回200状态码和成功消息
                return Ok(new { message = "删除成功", success = true });
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "删除免疫信息失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "删除失败", success = false });
            }
        }

        /// <summary>
        /// 创建新的企业信息（养殖阶段的企业信息）
        /// </summary>
        /// <param name="createDto">创建企业信息的DTO对象</param>
        /// <returns>创建成功返回200状态码和新创建的企业信息</returns>
        [HttpPost("enterprise")] // HTTP POST请求，路径为 api/Farming/enterprise
        public async Task<ActionResult<EnterpriseResponseDto>> CreateEnterprise([FromBody] CreateEnterpriseDto createDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层创建企业信息
                var result = await _farmingService.CreateEnterpriseAsync(createDto);
                // 返回200状态码和创建结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志
                _logger.LogError(ex, "创建企业信息失败");
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "创建失败", success = false });
            }
        }

        /// <summary>
        /// 更新现有的企业信息
        /// </summary>
        /// <param name="updateDto">包含更新数据的DTO对象</param>
        /// <returns>更新成功返回200状态码和更新后的企业信息</returns>
        [HttpPut("enterprise")] // HTTP PUT请求，路径为 api/Farming/enterprise
        public async Task<ActionResult<EnterpriseResponseDto>> UpdateEnterprise([FromBody] UpdateEnterpriseDto updateDto)
        {
            try
            {
                // 验证模型状态，检查数据验证注解
                if (!ModelState.IsValid)
                {
                    // 如果验证失败，返回400错误和验证错误信息
                    return BadRequest(ModelState);
                }

                // 调用服务层更新企业信息
                var result = await _farmingService.UpdateEnterpriseAsync(updateDto);
                // 如果更新失败（未找到记录），返回404未找到
                if (result == null)
                {
                    return NotFound(new { message = "未找到指定的企业信息", success = false });
                }
                // 返回200状态码和更新后的结果
                return Ok(result);
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含更新DTO的ID
                _logger.LogError(ex, "更新企业信息失败，ID: {Id}", updateDto.Id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "更新失败", success = false });
            }
        }

        /// <summary>
        /// 软删除指定的企业信息（逻辑删除，不物理删除）
        /// </summary>
        /// <param name="id">要删除的企业信息ID</param>
        /// <returns>删除结果，包含成功/失败状态和消息</returns>
        [HttpDelete("enterprise/{id}")] // HTTP DELETE请求，路径为 api/Farming/enterprise/{id}
        public async Task<ActionResult<object>> DeleteEnterprise(int id)
        {
            try
            {
                // 调用服务层执行软删除操作
                var result = await _farmingService.DeleteEnterpriseAsync(id);
                // 如果删除失败（未找到记录），返回404未找到
                if (!result)
                {
                    return NotFound(new { message = "未找到指定的企业信息", success = false });
                }
                // 返回200状态码和成功消息
                return Ok(new { message = "删除成功", success = true });
            }
            catch (Exception ex)
            {
                // 记录错误日志，包含ID参数
                _logger.LogError(ex, "删除企业信息失败，ID: {Id}", id);
                // 返回500服务器内部错误
                return StatusCode(500, new { message = "删除失败", success = false });
            }
        }
    }
}


